home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 335_03 / as8051.y < prev    next >
Encoding:
Lex Description  |  1990-12-02  |  39.3 KB  |  1,680 lines
  1. %{
  2.  
  3. /*
  4. HEADER:     ;
  5. TITLE:         Frankenstein Cross Assemblers;
  6. VERSION:     2.0;
  7. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  8.         Hex format object records.  ";
  9. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  10.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  11. SYSTEM:     UNIX, MS-Dos ;
  12. FILENAME:     as8051.y;
  13. WARNINGS:     "This software is in the public domain.  
  14.         Any prior copyright claims are relinquished.  
  15.  
  16.         This software is distributed with no warranty whatever.  
  17.         The author takes no responsibility for the consequences 
  18.         of its use.
  19.  
  20.         Yacc (or Bison) required to compile."  ;
  21. SEE-ALSO:     as8051.doc,frasmain.c;    
  22. AUTHORS:     Mark Zenier;
  23. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  24.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  25. */
  26. /* 8051 structured generation file */
  27. /* November 17, 1990 */
  28.  
  29. /*
  30.     description    frame work parser description for framework cross
  31.             assemblers
  32.     history        February 2, 1988
  33.             September 11, 1990 - merge table definition
  34.             September 12, 1990 - short file names
  35.             September 14, 1990 - short variable names
  36.             September 17, 1990 - use yylex as external
  37. */
  38. #include <stdio.h>
  39. #include "frasmdat.h"
  40. #include "fragcon.h"
  41.  
  42. #define yylex lexintercept
  43.  
  44. /*    0000.0000.0000.0xxx   register value */
  45. #define REGVALMASK    0x7
  46. /*    0xxx.xxxx.0000.0000    register and special select bits */
  47. #define REGSEL_ALL    0x7f00
  48. #define REG2NDSHFT    8
  49. #define REGSEL_ACC    0x100
  50. #define REGSEL_AB    0x200
  51. #define REGSEL_C    0x400
  52. #define REGSEL_DPTR    0x800
  53. #define REGSEL_PC    0x1000
  54. #define REGSEL_R01    0x2000
  55. #define REGSEL_R07    0x4000
  56. #define REG2SEL_ACC    0x1
  57. #define REG2SEL_AB    0x2
  58. #define REG2SEL_C    0x4
  59. #define REG2SEL_DPTR    0x8
  60. #define REG2SEL_PC    0x10
  61. #define REG2SEL_R01    0x20
  62. #define REG2SEL_R07    0x40
  63. #define ST_INH 0x1
  64. #define ST_UOP01 0x2
  65. #define ST_UOP02 0x4
  66. #define ST_UOP03 0x8
  67. #define ST_UOP04 0x10
  68. #define ST_UOP05 0x20
  69. #define ST_ALU01 0x1
  70. #define ST_ALU02 0x2
  71. #define ST_ALU02E 0x4
  72. #define ST_ALU03 0x8
  73. #define ST_ALU04 0x10
  74. #define ST_ALU05 0x20
  75. #define ST_ALU06 0x40
  76. #define ST_ALU07 0x80
  77. #define ST_ALU08 0x100
  78. #define ST_ALU09 0x200
  79. #define ST_ALU10 0x400
  80. #define ST_MOV01 0x1
  81. #define ST_MOV02 0x2
  82. #define ST_MOV03 0x4
  83. #define ST_MOV04 0x8
  84. #define ST_MOV05 0x10
  85. #define ST_MOV06 0x20
  86. #define ST_MOV07 0x40
  87. #define ST_MOV08 0x80
  88. #define ST_MOV09 0x100
  89. #define ST_MOV10 0x200
  90. #define ST_MOV11 0x400
  91. #define ST_MOV12 0x800
  92. #define ST_MOV13 0x1000
  93. #define ST_MOV14 0x2000
  94. #define ST_CJNE1 0x1
  95. #define ST_CJNE2 0x2
  96. #define ST_CJNE3 0x4
  97.     
  98.     static char    genbdef[] = "[1=];";
  99.     static char    genwdef[] = "[1=]y"; /* x for normal, y for byte rev */
  100.     char ignosyn[] = "[Xinvalid syntax for instruction";
  101.     char ignosel[] = "[Xinvalid operands";
  102.  
  103.     long    labelloc;
  104.     static int satsub;
  105.     int    ifstkpt = 0;
  106.     int    fraifskip = FALSE;
  107.  
  108.     struct symel * endsymbol = SYMNULL;
  109.  
  110. %}
  111. %union {
  112.     int    intv;
  113.     long     longv;
  114.     char    *strng;
  115.     struct symel *symb;
  116. }
  117.  
  118. %token <intv> REG
  119. %type <intv> bit
  120. %token <intv> KOC_BDEF
  121. %token <intv> KOC_ELSE
  122. %token <intv> KOC_END
  123. %token <intv> KOC_ENDI
  124. %token <intv> KOC_EQU
  125. %token <intv> KOC_IF
  126. %token <intv> KOC_INCLUDE
  127. %token <intv> KOC_ORG
  128. %token <intv> KOC_RESM
  129. %token <intv> KOC_SDEF
  130. %token <intv> KOC_SET
  131. %token <intv> KOC_WDEF
  132. %token <intv> KOC_CHSET
  133. %token <intv> KOC_CHDEF
  134. %token <intv> KOC_CHUSE
  135. %token <intv> KOC_opcode
  136. %token <intv> KOC_aluop
  137. %token <intv> KOC_mov
  138. %token <intv> KOC_cjne
  139.  
  140. %token <longv> CONSTANT
  141. %token EOL
  142. %token KEOP_AND
  143. %token KEOP_DEFINED
  144. %token KEOP_EQ
  145. %token KEOP_GE
  146. %token KEOP_GT
  147. %token KEOP_HIGH
  148. %token KEOP_LE
  149. %token KEOP_LOW
  150. %token KEOP_LT
  151. %token KEOP_MOD
  152. %token KEOP_MUN
  153. %token KEOP_NE
  154. %token KEOP_NOT
  155. %token KEOP_OR
  156. %token KEOP_SHL
  157. %token KEOP_SHR
  158. %token KEOP_XOR
  159. %token KEOP_locctr
  160. %token <symb> LABEL
  161. %token <strng> STRING
  162. %token <symb> SYMBOL
  163.  
  164. %token KTK_invalid
  165.  
  166. %right    KEOP_HIGH KEOP_LOW
  167. %left    KEOP_OR KEOP_XOR
  168. %left    KEOP_AND
  169. %right    KEOP_NOT
  170. %nonassoc    KEOP_GT KEOP_GE KEOP_LE KEOP_LT KEOP_NE KEOP_EQ
  171. %left    '+' '-'
  172. %left    '*' '/' KEOP_MOD KEOP_SHL KEOP_SHR
  173. %right    KEOP_MUN
  174.  
  175.  
  176. %type <intv> expr exprlist stringlist
  177.  
  178. %start file
  179.  
  180. %%
  181.  
  182. file    :    file allline
  183.     |    allline
  184.     ;
  185.  
  186. allline    :     line EOL
  187.             {
  188.                 clrexpr();
  189.             }
  190.     |    EOL
  191.     |    error EOL
  192.             {
  193.                 clrexpr();
  194.                 yyerrok;
  195.             }
  196.     ;
  197.  
  198. line    :    LABEL KOC_END 
  199.             {
  200.                 endsymbol = $1;
  201.                 nextreadact = Nra_end;
  202.             }
  203.     |          KOC_END 
  204.             {
  205.                 nextreadact = Nra_end;
  206.             }
  207.     |    KOC_INCLUDE STRING
  208.             {
  209.         if(nextfstk >= FILESTKDPTH)
  210.         {
  211.             fraerror("include file nesting limit exceeded");
  212.         }
  213.         else
  214.         {
  215.             infilestk[nextfstk].fnm = savestring($2,strlen($2));
  216.             if( (infilestk[nextfstk].fpt = fopen($2,"r"))
  217.                 ==(FILE *)NULL )
  218.             {
  219.                 fraerror("cannot open include file");
  220.             }
  221.             else
  222.             {
  223.                 nextreadact = Nra_new;
  224.             }
  225.         }
  226.             }
  227.     |    LABEL KOC_EQU expr 
  228.             {
  229.                 if($1 -> seg == SSG_UNDEF)
  230.                 {
  231.                     pevalexpr(0, $3);
  232.                     if(evalr[0].seg == SSG_ABS)
  233.                     {
  234.                         $1 -> seg = SSG_EQU;
  235.                         $1 -> value = evalr[0].value;
  236.                         prtequvalue("C: 0x%lx\n",
  237.                             evalr[0].value);
  238.                     }
  239.                     else
  240.                     {
  241.                         fraerror(
  242.                     "noncomputable expression for EQU");
  243.                     }
  244.                 }
  245.                 else
  246.                 {
  247.                     fraerror(
  248.                 "cannot change symbol value with EQU");
  249.                 }
  250.             }
  251.     |    LABEL KOC_SET expr 
  252.             {
  253.                 if($1 -> seg == SSG_UNDEF
  254.                    || $1 -> seg == SSG_SET)
  255.                 {
  256.                     pevalexpr(0, $3);
  257.                     if(evalr[0].seg == SSG_ABS)
  258.                     {
  259.                         $1 -> seg = SSG_SET;
  260.                         $1 -> value = evalr[0].value;
  261.                         prtequvalue("C: 0x%lx\n",
  262.                             evalr[0].value);
  263.                     }
  264.                     else
  265.                     {
  266.                         fraerror(
  267.                     "noncomputable expression for SET");
  268.                     }
  269.                 }
  270.                 else
  271.                 {
  272.                     fraerror(
  273.                 "cannot change symbol value with SET");
  274.                 }
  275.             }
  276.     |    KOC_IF expr 
  277.             {
  278.         if((++ifstkpt) < IFSTKDEPTH)
  279.         {
  280.             pevalexpr(0, $2);
  281.             if(evalr[0].seg == SSG_ABS)
  282.             {
  283.                 if(evalr[0].value != 0)
  284.                 {
  285.                     elseifstk[ifstkpt] = If_Skip;
  286.                     endifstk[ifstkpt] = If_Active;
  287.                 }
  288.                 else
  289.                 {
  290.                     fraifskip = TRUE;
  291.                     elseifstk[ifstkpt] = If_Active;
  292.                     endifstk[ifstkpt] = If_Active;
  293.                 }
  294.             }
  295.             else
  296.             {
  297.                 fraifskip = TRUE;
  298.                 elseifstk[ifstkpt] = If_Active;
  299.                 endifstk[ifstkpt] = If_Active;
  300.             }
  301.         }
  302.         else
  303.         {
  304.             fraerror("IF stack overflow");
  305.         }
  306.             }
  307.                         
  308.     |    KOC_IF 
  309.             {
  310.         if(fraifskip) 
  311.         {
  312.             if((++ifstkpt) < IFSTKDEPTH)
  313.             {
  314.                     elseifstk[ifstkpt] = If_Skip;
  315.                     endifstk[ifstkpt] = If_Skip;
  316.             }
  317.             else
  318.             {
  319.                 fraerror("IF stack overflow");
  320.             }
  321.         }
  322.         else
  323.         {
  324.             yyerror("syntax error");
  325.             YYERROR;
  326.         }
  327.                 }
  328.                         
  329.     |    KOC_ELSE 
  330.             {
  331.                 switch(elseifstk[ifstkpt])
  332.                 {
  333.                 case If_Active:
  334.                     fraifskip = FALSE;
  335.                     break;
  336.                 
  337.                 case If_Skip:
  338.                     fraifskip = TRUE;
  339.                     break;
  340.                 
  341.                 case If_Err:
  342.                     fraerror("ELSE with no matching if");
  343.                     break;
  344.                 }
  345.             }
  346.  
  347.     |    KOC_ENDI 
  348.             {
  349.                 switch(endifstk[ifstkpt])
  350.                 {
  351.                 case If_Active:
  352.                     fraifskip = FALSE;
  353.                     ifstkpt--;
  354.                     break;
  355.                 
  356.                 case If_Skip:
  357.                     fraifskip = TRUE;
  358.                     ifstkpt--;
  359.                     break;
  360.                 
  361.                 case If_Err:
  362.                     fraerror("ENDI with no matching if");
  363.                     break;
  364.                 }
  365.             }
  366.     |    LABEL KOC_ORG expr 
  367.             {
  368.                 pevalexpr(0, $3);
  369.                 if(evalr[0].seg == SSG_ABS)
  370.                 {
  371.                     locctr = labelloc = evalr[0].value;
  372.                     if($1 -> seg == SSG_UNDEF)
  373.                     {
  374.                         $1 -> seg = SSG_ABS;
  375.                         $1 -> value = labelloc;
  376.                     }
  377.                     else
  378.                         fraerror(
  379.                         "multiple definition of label");
  380.                     prtequvalue("C: 0x%lx\n",
  381.                         evalr[0].value);
  382.                 }
  383.                 else
  384.                 {
  385.                     fraerror(
  386.                      "noncomputable expression for ORG");
  387.                 }
  388.             }
  389.     |          KOC_ORG expr 
  390.             {
  391.                 pevalexpr(0, $2);
  392.                 if(evalr[0].seg == SSG_ABS)
  393.                 {
  394.                     locctr = labelloc = evalr[0].value;
  395.                     prtequvalue("C: 0x%lx\n",
  396.                         evalr[0].value);
  397.                 }
  398.                 else
  399.                 {
  400.                     fraerror(
  401.                      "noncomputable expression for ORG");
  402.                 }
  403.             }
  404.     |    LABEL KOC_CHSET
  405.             {
  406.                 if($1 -> seg == SSG_UNDEF)
  407.                 {
  408.                     $1 -> seg = SSG_EQU;
  409.                     if( ($1->value = chtcreate()) <= 0)
  410.                     {
  411.         fraerror( "cannot create character translation table");
  412.                     }
  413.                     prtequvalue("C: 0x%lx\n", $1 -> value);
  414.                 }
  415.                 else
  416.                 {
  417.             fraerror( "multiple definition of label");
  418.                 }
  419.             }
  420.     |        KOC_CHUSE
  421.             {
  422.                 chtcpoint = (int *) NULL;
  423.                 prtequvalue("C: 0x%lx\n", 0L);
  424.             }
  425.     |        KOC_CHUSE expr
  426.             {
  427.                 pevalexpr(0, $2);
  428.                 if( evalr[0].seg == SSG_ABS)
  429.                 {
  430.                     if( evalr[0].value == 0)
  431.                     {
  432.                         chtcpoint = (int *)NULL;
  433.                         prtequvalue("C: 0x%lx\n", 0L);
  434.                     }
  435.                     else if(evalr[0].value < chtnxalph)
  436.                     {
  437.                 chtcpoint = chtatab[evalr[0].value];
  438.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  439.                     }
  440.                     else
  441.                     {
  442.             fraerror("nonexistent character translation table");
  443.                     }
  444.                 }
  445.                 else
  446.                 {
  447.                     fraerror("noncomputable expression");
  448.                 }
  449.             }
  450.     |        KOC_CHDEF STRING ',' exprlist
  451.             {
  452.         int findrv, numret, *charaddr;
  453.         char *sourcestr = $2, *before;
  454.  
  455.         if(chtnpoint != (int *)NULL)
  456.         {
  457.             for(satsub = 0; satsub < $4; satsub++)
  458.             {
  459.                 before = sourcestr;
  460.  
  461.                 pevalexpr(0, exprlist[satsub]);
  462.                 findrv = chtcfind(chtnpoint, &sourcestr,
  463.                         &charaddr, &numret);
  464.                 if(findrv == CF_END)
  465.                 {
  466.             fraerror("more expressions than characters");
  467.                     break;
  468.                 }
  469.  
  470.                 if(evalr[0].seg == SSG_ABS)
  471.                 {
  472.                     switch(findrv)
  473.                     {
  474.                     case CF_UNDEF:
  475.                         {
  476.                 if(evalr[0].value < 0 ||
  477.                     evalr[0].value > 255)
  478.                 {
  479.             frawarn("character translation value truncated");
  480.                 }
  481.                 *charaddr = evalr[0].value & 0xff;
  482.                 prtequvalue("C: 0x%lx\n", evalr[0].value);
  483.                         }
  484.                         break;
  485.  
  486.                     case CF_INVALID:
  487.                     case CF_NUMBER:
  488.                 fracherror("invalid character to define", 
  489.                     before, sourcestr);
  490.                         break;
  491.  
  492.                     case CF_CHAR:
  493.                 fracherror("character already defined", 
  494.                     before, sourcestr);
  495.                         break;
  496.                     }
  497.                 }
  498.                 else
  499.                 {
  500.                     fraerror("noncomputable expression");
  501.                 }
  502.             }
  503.  
  504.             if( *sourcestr != '\0')
  505.             {
  506.                 fraerror("more characters than expressions");
  507.             }
  508.         }
  509.         else
  510.         {
  511.             fraerror("no CHARSET statement active");
  512.         }
  513.             
  514.             }
  515.     |    LABEL 
  516.             {
  517.             if($1 -> seg == SSG_UNDEF)
  518.             {
  519.                 $1 -> seg = SSG_ABS;
  520.                 $1 -> value = labelloc;
  521.                 prtequvalue("C: 0x%lx\n", labelloc);
  522.  
  523.             }
  524.             else
  525.                 fraerror(
  526.                 "multiple definition of label");
  527.             }
  528.     |    labeledline
  529.     ;
  530.  
  531. labeledline :    LABEL genline
  532.             {
  533.             if($1 -> seg == SSG_UNDEF)
  534.             {
  535.                 $1 -> seg = SSG_ABS;
  536.                 $1 -> value = labelloc;
  537.             }
  538.             else
  539.                 fraerror(
  540.                 "multiple definition of label");
  541.             labelloc = locctr;
  542.             }
  543.                 
  544.     |    genline
  545.             {
  546.                 labelloc = locctr;
  547.             }
  548.     ;
  549.  
  550. genline    :    KOC_BDEF    exprlist 
  551.             {
  552.                 genlocrec(currseg, labelloc);
  553.                 for( satsub = 0; satsub < $2; satsub++)
  554.                 {
  555.                     pevalexpr(1, exprlist[satsub]);
  556.                     locctr += geninstr(genbdef);
  557.                 }
  558.             }
  559.     |    KOC_SDEF stringlist 
  560.             {
  561.                 genlocrec(currseg, labelloc);
  562.                 for(satsub = 0; satsub < $2; satsub++)
  563.                 {
  564.                     locctr += genstring(stringlist[satsub]);
  565.                 }
  566.             }
  567.     |    KOC_WDEF exprlist 
  568.             {
  569.                 genlocrec(currseg, labelloc);
  570.                 for( satsub = 0; satsub < $2; satsub++)
  571.                 {
  572.                     pevalexpr(1, exprlist[satsub]);
  573.                     locctr += geninstr(genwdef);
  574.                 }
  575.             }    
  576.     |    KOC_RESM expr 
  577.             {
  578.                 pevalexpr(0, $2);
  579.                 if(evalr[0].seg == SSG_ABS)
  580.                 {
  581.                     locctr = labelloc + evalr[0].value;
  582.                     prtequvalue("C: 0x%lx\n", labelloc);
  583.                 }
  584.                 else
  585.                 {
  586.                     fraerror(
  587.                  "noncomputable result for RMB expression");
  588.                 }
  589.             }
  590.     ;
  591.  
  592. exprlist :    exprlist ',' expr
  593.             {
  594.                 exprlist[nextexprs ++ ] = $3;
  595.                 $$ = nextexprs;
  596.             }
  597.     |    expr
  598.             {
  599.                 nextexprs = 0;
  600.                 exprlist[nextexprs ++ ] = $1;
  601.                 $$ = nextexprs;
  602.             }
  603.     ;
  604.  
  605. stringlist :    stringlist ',' STRING
  606.             {
  607.                 stringlist[nextstrs ++ ] = $3;
  608.                 $$ = nextstrs;
  609.             }
  610.     |    STRING
  611.             {
  612.                 nextstrs = 0;
  613.                 stringlist[nextstrs ++ ] = $1;
  614.                 $$ = nextstrs;
  615.             }
  616.     ;
  617.  
  618.  
  619. genline : KOC_opcode 
  620.             {
  621.         genlocrec(currseg, labelloc);
  622.         locctr += geninstr(findgen($1, ST_INH,  0));
  623.             }
  624.     ;
  625. genline : KOC_opcode  '@' REG
  626.             {
  627.         genlocrec(currseg, labelloc);
  628.         evalr[1].value = ( $3 & REGVALMASK);
  629.         locctr += geninstr(findgen($1, ST_UOP01,  ($3 & REGSEL_ALL)));
  630.             }
  631.     ;
  632. genline : KOC_opcode  REG
  633.             {
  634.         genlocrec(currseg, labelloc);
  635.         evalr[1].value = ( $2 & REGVALMASK);
  636.         locctr += geninstr(findgen($1, ST_UOP02,  ($2 & REGSEL_ALL)));
  637.             }
  638.     ;
  639. genline : KOC_opcode  bit
  640.             {
  641.         genlocrec(currseg, labelloc);
  642.         evalr[1].value = $2;
  643.         locctr += geninstr(findgen($1, ST_UOP03,  0));
  644.             }
  645.     ;
  646. genline : KOC_opcode  expr
  647.             {
  648.         genlocrec(currseg, labelloc);
  649.         pevalexpr(1,$2);
  650.         locctr += geninstr(findgen($1, ST_UOP04,  0));
  651.             }
  652.     ;
  653. genline : KOC_opcode  '@' REG '+' REG
  654.             {
  655.         genlocrec(currseg, labelloc);
  656.         locctr += geninstr(findgen($1, ST_UOP05, ($3 & REGSEL_ALL) 
  657.             | (($5 & REGSEL_ALL) >> REG2NDSHFT) ));
  658.             }
  659.     ;
  660. genline : KOC_aluop  REG ',' '#' expr
  661.             {
  662.         genlocrec(currseg, labelloc);
  663.         evalr[1].value = ( $2 & REGVALMASK);
  664.         pevalexpr(2,$5);
  665.         locctr += geninstr(findgen($1, ST_ALU01,  ($2 & REGSEL_ALL)));
  666.             }
  667.     ;
  668. genline : KOC_aluop  REG ',' '/' bit
  669.             {
  670.         genlocrec(currseg, labelloc);
  671.         evalr[1].value = ( $2 & REGVALMASK);
  672.         evalr[2].value = $5;
  673.         locctr += geninstr(findgen($1, ST_ALU02,  ($2 & REGSEL_ALL)));
  674.             }
  675.     ;
  676. genline : KOC_aluop  REG ',' '/' expr
  677.             {
  678.         genlocrec(currseg, labelloc);
  679.         evalr[1].value = ( $2 & REGVALMASK);
  680.         pevalexpr(2,$5);
  681.         locctr += geninstr(findgen($1, ST_ALU02E,  ($2 & REGSEL_ALL)));
  682.             }
  683.     ;
  684. genline : KOC_aluop  REG ',' '@' REG
  685.             {
  686.         genlocrec(currseg, labelloc);
  687.         evalr[1].value = ( $2 & REGVALMASK);
  688.         evalr[2].value = ( $5 & REGVALMASK);
  689.         locctr += geninstr(findgen($1, ST_ALU03,  ($2 & REGSEL_ALL) 
  690.             | (($5 & REGSEL_ALL) >> REG2NDSHFT)));
  691.             }
  692.     ;
  693. genline : KOC_aluop  REG ',' REG
  694.             {
  695.         genlocrec(currseg, labelloc);
  696.         evalr[1].value = ( $2 & REGVALMASK);
  697.         evalr[2].value = ( $4 & REGVALMASK);
  698.         locctr += geninstr(findgen($1, ST_ALU04,  ($2 & REGSEL_ALL) 
  699.             | (($4 & REGSEL_ALL) >> REG2NDSHFT)));
  700.             }
  701.     ;
  702. genline : KOC_aluop  REG ',' bit
  703.             {
  704.         genlocrec(currseg, labelloc);
  705.         evalr[1].value = ( $2 & REGVALMASK);
  706.         evalr[2].value = $4;
  707.         locctr += geninstr(findgen($1, ST_ALU05,  ($2 & REGSEL_ALL)));
  708.             }
  709.     ;
  710. genline : KOC_aluop  REG ',' expr
  711.             {
  712.         genlocrec(currseg, labelloc);
  713.         evalr[1].value = ( $2 & REGVALMASK);
  714.         pevalexpr(2,$4);
  715.         locctr += geninstr(findgen($1, ST_ALU06,  ($2 & REGSEL_ALL)));
  716.             }
  717.     ;
  718. genline : KOC_aluop  bit ',' expr
  719.             {
  720.         genlocrec(currseg, labelloc);
  721.         evalr[1].value = $2;
  722.         pevalexpr(2,$4);
  723.         locctr += geninstr(findgen($1, ST_ALU07,  0));
  724.             }
  725.     ;
  726. genline : KOC_aluop  expr ',' '#' expr
  727.             {
  728.         genlocrec(currseg, labelloc);
  729.         pevalexpr(1,$2);
  730.         pevalexpr(2,$5);
  731.         locctr += geninstr(findgen($1, ST_ALU08,  0));
  732.             }
  733.     ;
  734. genline : KOC_aluop  expr ',' REG
  735.             {
  736.         genlocrec(currseg, labelloc);
  737.         pevalexpr(1,$2);
  738.         evalr[2].value = ( $4 & REGVALMASK);
  739.         locctr += geninstr(findgen($1, ST_ALU09,  ($4 & REGSEL_ALL)));
  740.             }
  741.     ;
  742. genline : KOC_aluop  expr ',' expr
  743.             {
  744.         genlocrec(currseg, labelloc);
  745.         pevalexpr(1,$2);
  746.         pevalexpr(2,$4);
  747.         locctr += geninstr(findgen($1, ST_ALU10,  0));
  748.             }
  749.     ;
  750. genline : KOC_mov  '@' REG ',' '#' expr
  751.             {
  752.         genlocrec(currseg, labelloc);
  753.         evalr[1].value = ( $3 & REGVALMASK);
  754.         pevalexpr(2,$6);
  755.         locctr += geninstr(findgen($1, ST_MOV01,  ($3 & REGSEL_ALL)));
  756.             }
  757.     ;
  758. genline : KOC_mov  '@' REG ',' REG
  759.             {
  760.         genlocrec(currseg, labelloc);
  761.         evalr[1].value = ( $3 & REGVALMASK);
  762.         evalr[2].value = ( $5 & REGVALMASK);
  763.         locctr += geninstr(findgen($1, ST_MOV02,  ($3 & REGSEL_ALL) 
  764.             | (($5 & REGSEL_ALL) >> REG2NDSHFT)));
  765.             }
  766.     ;
  767. genline : KOC_mov  '@' REG ',' expr
  768.             {
  769.         genlocrec(currseg, labelloc);
  770.         evalr[1].value = ( $3 & REGVALMASK);
  771.         pevalexpr(2,$5);
  772.         locctr += geninstr(findgen($1, ST_MOV03,  ($3 & REGSEL_ALL)));
  773.             }
  774.     ;
  775. genline : KOC_mov  REG ',' '#' expr
  776.             {
  777.         genlocrec(currseg, labelloc);
  778.         evalr[1].value = ( $2 & REGVALMASK);
  779.         pevalexpr(2,$5);
  780.         locctr += geninstr(findgen($1, ST_MOV04,  ($2 & REGSEL_ALL)));
  781.             }
  782.     ;
  783. genline : KOC_mov  REG ',' '@' REG
  784.             {
  785.         genlocrec(currseg, labelloc);
  786.         evalr[1].value = ( $2 & REGVALMASK);
  787.         evalr[2].value = ( $5 & REGVALMASK);
  788.         locctr += geninstr(findgen($1, ST_MOV05,  ($2 & REGSEL_ALL) 
  789.             | (($5 & REGSEL_ALL) >> REG2NDSHFT)));
  790.             }
  791.     ;
  792. genline : KOC_mov  REG ',' '@' REG '+' REG
  793.             {
  794.         genlocrec(currseg, labelloc);
  795.         locctr += geninstr(findgen($1, ST_MOV06,  (($2&$5) & REGSEL_ALL)
  796.             | (($7 & REGSEL_ALL) >> REG2NDSHFT)));
  797.             }
  798.     ;
  799. genline : KOC_mov  REG ',' REG
  800.             {
  801.         genlocrec(currseg, labelloc);
  802.         evalr[1].value = ( $2 & REGVALMASK);
  803.         evalr[2].value = ( $4 & REGVALMASK);
  804.         locctr += geninstr(findgen($1, ST_MOV07,  ($2 & REGSEL_ALL) 
  805.             | (($4 & REGSEL_ALL) >> REG2NDSHFT)));
  806.             }
  807.     ;
  808. genline : KOC_mov  REG ',' bit
  809.             {
  810.         genlocrec(currseg, labelloc);
  811.         evalr[1].value = ( $2 & REGVALMASK);
  812.         evalr[2].value = $4;
  813.         locctr += geninstr(findgen($1, ST_MOV08,  ($2 & REGSEL_ALL)));
  814.             }
  815.     ;
  816. genline : KOC_mov  REG ',' expr
  817.             {
  818.         genlocrec(currseg, labelloc);
  819.         evalr[1].value = ( $2 & REGVALMASK);
  820.         pevalexpr(2,$4);
  821.         locctr += geninstr(findgen($1, ST_MOV09,  ($2 & REGSEL_ALL)));
  822.             }
  823.     ;
  824. genline : KOC_mov  bit ',' REG
  825.             {
  826.         genlocrec(currseg, labelloc);
  827.         evalr[1].value = $2;
  828.         evalr[2].value = ( $4 & REGVALMASK);
  829.         locctr += geninstr(findgen($1, ST_MOV10,  ($4 & REGSEL_ALL)));
  830.             }
  831.     ;
  832. genline : KOC_mov  expr ',' '#' expr
  833.             {
  834.         genlocrec(currseg, labelloc);
  835.         pevalexpr(1,$2);
  836.         pevalexpr(2,$5);
  837.         locctr += geninstr(findgen($1, ST_MOV11,  0));
  838.             }
  839.     ;
  840. genline : KOC_mov  expr ',' '@' REG
  841.             {
  842.         genlocrec(currseg, labelloc);
  843.         pevalexpr(1,$2);
  844.         evalr[2].value = ( $5 & REGVALMASK);
  845.         locctr += geninstr(findgen($1, ST_MOV12,  ($5 & REGSEL_ALL)));
  846.             }
  847.     ;
  848. genline : KOC_mov  expr ',' REG
  849.             {
  850.         genlocrec(currseg, labelloc);
  851.         pevalexpr(1,$2);
  852.         evalr[2].value = ($4 & REGVALMASK);
  853.         locctr += geninstr(findgen($1, ST_MOV13,  ($4 & REGSEL_ALL)));
  854.             }
  855.     ;
  856. genline : KOC_mov  expr ',' expr
  857.             {
  858.         genlocrec(currseg, labelloc);
  859.         pevalexpr(1,$2);
  860.         pevalexpr(2,$4);
  861.         locctr += geninstr(findgen($1, ST_MOV14,  0));
  862.             }
  863.     ;
  864. genline : KOC_cjne  REG ',' expr ',' expr
  865.             {
  866.         genlocrec(currseg, labelloc);
  867.         evalr[1].value = ( $2 & REGVALMASK);
  868.         pevalexpr(2,$4);
  869.         pevalexpr(3,$6);
  870.         locctr += geninstr(findgen($1, ST_CJNE1,  ($2 & REGSEL_ALL)));
  871.             }
  872.     ;
  873. genline : KOC_cjne  REG ',' '#' expr ',' expr
  874.             {
  875.         genlocrec(currseg, labelloc);
  876.         evalr[1].value = ( $2 & REGVALMASK);
  877.         pevalexpr(2,$5);
  878.         pevalexpr(3,$7);
  879.         locctr += geninstr(findgen($1, ST_CJNE2,  ($2 & REGSEL_ALL)));
  880.             }
  881.     ;
  882. genline : KOC_cjne  '@' REG ',' '#' expr ',' expr
  883.             {
  884.         genlocrec(currseg, labelloc);
  885.         evalr[1].value = ( $3 & REGVALMASK);
  886.         pevalexpr(2,$6);
  887.         pevalexpr(3,$8);
  888.         locctr += geninstr(findgen($1, ST_CJNE3,  ($3 & REGSEL_ALL)));
  889.             }
  890.     ;
  891. bit    :    expr '.' CONSTANT
  892.         {
  893.             int    bitaddr;
  894.  
  895.             pevalexpr(0, $1);
  896.             if(evalr[0].seg == SSG_ABS)
  897.             {
  898.                 switch((int)(evalr[0].value))
  899.                 {
  900.                 case 0x20:
  901.                 case 0x21:
  902.                 case 0x22:
  903.                 case 0x23:
  904.                 case 0x24:
  905.                 case 0x25:
  906.                 case 0x26:
  907.                 case 0x27:
  908.                 case 0x28:
  909.                 case 0x29:
  910.                 case 0x2a:
  911.                 case 0x2b:
  912.                 case 0x2c:
  913.                 case 0x2d:
  914.                 case 0x2e:
  915.                 case 0x2f:
  916.                     bitaddr = (evalr[0].value - 0x20)
  917.                             << 3;
  918.                     break;
  919.  
  920.                 case 0x80:
  921.                 case 0x88:
  922.                 case 0x90:
  923.                 case 0x98:
  924.                 case 0xa0:
  925.                 case 0xa8:
  926.                 case 0xb0:
  927.                 case 0xb8:
  928.                 case 0xc0:
  929.                 case 0xc8:
  930.                 case 0xd0:
  931.                 case 0xd8:
  932.                 case 0xe0:
  933.                 case 0xe8:
  934.                 case 0xf0:
  935.                 case 0xf8:
  936.                     bitaddr = evalr[0].value;
  937.                     break;
  938.  
  939.                 default:
  940.                     fraerror(
  941.                     "location is not bit addressable");
  942.                     evalr[0].value = 0;
  943.                     break;
  944.                 }
  945.             }
  946.             else
  947.             {
  948.                 fraerror(
  949.             "noncomputable expression in bit address");    
  950.                 evalr[0].value = 0;
  951.             }
  952.             
  953.             if($3 < 0 || $3 > 7)
  954.             {
  955.                 fraerror("bit number invalid");
  956.             }
  957.  
  958.             $$ = bitaddr + $3;
  959.         }
  960.     ;
  961.  
  962. expr    :    '+' expr %prec KEOP_MUN
  963.             {
  964.                 $$ = $2;
  965.             }
  966.     |    '-' expr %prec KEOP_MUN
  967.             {
  968.                 $$ = exprnode(PCCASE_UN,$2,IFC_NEG,0,0L,
  969.                     SYMNULL);
  970.             }
  971.     |    KEOP_NOT expr
  972.             {
  973.                 $$ = exprnode(PCCASE_UN,$2,IFC_NOT,0,0L,
  974.                     SYMNULL);
  975.             }
  976.     |    KEOP_HIGH expr
  977.             {
  978.                 $$ = exprnode(PCCASE_UN,$2,IFC_HIGH,0,0L,
  979.                     SYMNULL);
  980.             }
  981.     |    KEOP_LOW expr
  982.             {
  983.                 $$ = exprnode(PCCASE_UN,$2,IFC_LOW,0,0L,
  984.                     SYMNULL);
  985.             }
  986.     |    expr '*' expr
  987.             {
  988.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MUL,$3,0L,
  989.                     SYMNULL);
  990.             }
  991.     |    expr '/' expr
  992.             {
  993.                 $$ = exprnode(PCCASE_BIN,$1,IFC_DIV,$3,0L,
  994.                     SYMNULL);
  995.             }
  996.     |    expr '+' expr
  997.             {
  998.                 $$ = exprnode(PCCASE_BIN,$1,IFC_ADD,$3,0L,
  999.                     SYMNULL);
  1000.             }
  1001.     |    expr '-' expr
  1002.             {
  1003.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SUB,$3,0L,
  1004.                     SYMNULL);
  1005.             }
  1006.     |    expr KEOP_MOD expr
  1007.             {
  1008.                 $$ = exprnode(PCCASE_BIN,$1,IFC_MOD,$3,0L,
  1009.                     SYMNULL);
  1010.             }
  1011.     |    expr KEOP_SHL expr
  1012.             {
  1013.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHL,$3,0L,
  1014.                     SYMNULL);
  1015.             }
  1016.     |    expr KEOP_SHR expr
  1017.             {
  1018.                 $$ = exprnode(PCCASE_BIN,$1,IFC_SHR,$3,0L,
  1019.                     SYMNULL);
  1020.             }
  1021.     |    expr KEOP_GT expr
  1022.             {
  1023.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GT,$3,0L,
  1024.                     SYMNULL);
  1025.             }
  1026.     |    expr KEOP_GE expr
  1027.             {
  1028.                 $$ = exprnode(PCCASE_BIN,$1,IFC_GE,$3,0L,
  1029.                     SYMNULL);
  1030.             }
  1031.     |    expr KEOP_LT expr
  1032.             {
  1033.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LT,$3,0L,
  1034.                     SYMNULL);
  1035.             }
  1036.     |    expr KEOP_LE expr
  1037.             {
  1038.                 $$ = exprnode(PCCASE_BIN,$1,IFC_LE,$3,0L,
  1039.                     SYMNULL);
  1040.             }
  1041.     |    expr KEOP_NE expr
  1042.             {
  1043.                 $$ = exprnode(PCCASE_BIN,$1,IFC_NE,$3,0L,
  1044.                     SYMNULL);
  1045.             }
  1046.     |    expr KEOP_EQ expr
  1047.             {
  1048.                 $$ = exprnode(PCCASE_BIN,$1,IFC_EQ,$3,0L,
  1049.                     SYMNULL);
  1050.             }
  1051.     |    expr KEOP_AND expr
  1052.             {
  1053.                 $$ = exprnode(PCCASE_BIN,$1,IFC_AND,$3,0L,
  1054.                     SYMNULL);
  1055.             }
  1056.     |    expr KEOP_OR expr
  1057.             {
  1058.                 $$ = exprnode(PCCASE_BIN,$1,IFC_OR,$3,0L,
  1059.                     SYMNULL);
  1060.             }
  1061.     |    expr KEOP_XOR expr
  1062.             {
  1063.                 $$ = exprnode(PCCASE_BIN,$1,IFC_XOR,$3,0L,
  1064.                     SYMNULL);
  1065.             }
  1066.     |    KEOP_DEFINED SYMBOL
  1067.             {
  1068.                 $$ = exprnode(PCCASE_DEF,0,IGP_DEFINED,0,0L,$2);
  1069.             }
  1070.     |    SYMBOL
  1071.             {
  1072.                 $$ = exprnode(PCCASE_SYMB,0,IFC_SYMB,0,0L,$1);
  1073.             }
  1074.     |    '*'
  1075.             {
  1076.                 $$ = exprnode(PCCASE_PROGC,0,IFC_PROGCTR,0,
  1077.                     labelloc, SYMNULL);
  1078.             }
  1079.     |    CONSTANT
  1080.             {
  1081.                 $$ = exprnode(PCCASE_CONS,0,IGP_CONSTANT,0,$1,
  1082.                     SYMNULL);
  1083.             }
  1084.     |    STRING
  1085.             {
  1086.                 char *sourcestr = $1;
  1087.                 long accval = 0;
  1088.  
  1089.                 if(strlen($1) > 0)
  1090.                 {
  1091.                     accval = chtran(&sourcestr);
  1092.                     if(*sourcestr != '\0')
  1093.                     {
  1094.                         accval = (accval << 8) +
  1095.                             chtran(&sourcestr);
  1096.                     }
  1097.  
  1098.                     if( *sourcestr != '\0')
  1099.                     {
  1100.     frawarn("string constant in expression more than 2 characters long");
  1101.                     }
  1102.                 }
  1103.                 $$ = exprnode(PCCASE_CONS, 0, IGP_CONSTANT, 0,
  1104.                     accval, SYMNULL);
  1105.             }
  1106.     |    '(' expr ')'
  1107.             {
  1108.                 $$ = $2;
  1109.             }
  1110.     ;
  1111.  
  1112.  
  1113.  
  1114. %%
  1115.  
  1116. lexintercept()
  1117. /*
  1118.     description    intercept the call to yylex (the lexical analyzer)
  1119.             and filter out all unnecessary tokens when skipping
  1120.             the input between a failed IF and its matching ENDI or
  1121.             ELSE
  1122.     globals     fraifskip    the enable flag
  1123. */
  1124. {
  1125. #undef yylex
  1126.  
  1127.     int rv;
  1128.  
  1129.     if(fraifskip)
  1130.     {
  1131.         for(;;)
  1132.         {
  1133.  
  1134.             switch(rv = yylex())
  1135.  
  1136.             {
  1137.             case 0:
  1138.             case KOC_END:
  1139.             case KOC_IF:
  1140.             case KOC_ELSE:
  1141.             case KOC_ENDI:
  1142.             case EOL:
  1143.                 return rv;
  1144.             default:
  1145.                 break;
  1146.             }
  1147.         }
  1148.     }
  1149.     else
  1150.         return yylex();
  1151. #define yylex lexintercept
  1152. }
  1153.  
  1154.  
  1155.  
  1156. setreserved()
  1157. {
  1158.  
  1159.     reservedsym("and", KEOP_AND, 0);
  1160.     reservedsym("defined", KEOP_DEFINED,0);
  1161.     reservedsym("eq", KEOP_EQ, 0);
  1162.     reservedsym("ge", KEOP_GE, 0);
  1163.     reservedsym("gt", KEOP_GT, 0);
  1164.     reservedsym("high", KEOP_HIGH, 0);
  1165.     reservedsym("le", KEOP_LE, 0);
  1166.     reservedsym("low", KEOP_LOW, 0);
  1167.     reservedsym("lt", KEOP_LT, 0);
  1168.     reservedsym("mod", KEOP_MOD, 0);
  1169.     reservedsym("ne", KEOP_NE, 0);
  1170.     reservedsym("not", KEOP_NOT, 0);
  1171.     reservedsym("or", KEOP_OR, 0);
  1172.     reservedsym("shl", KEOP_SHL, 0);
  1173.     reservedsym("shr", KEOP_SHR, 0);
  1174.     reservedsym("xor", KEOP_XOR, 0);
  1175.     reservedsym("AND", KEOP_AND, 0);
  1176.     reservedsym("DEFINED", KEOP_DEFINED,0);
  1177.     reservedsym("EQ", KEOP_EQ, 0);
  1178.     reservedsym("GE", KEOP_GE, 0);
  1179.     reservedsym("GT", KEOP_GT, 0);
  1180.     reservedsym("HIGH", KEOP_HIGH, 0);
  1181.     reservedsym("LE", KEOP_LE, 0);
  1182.     reservedsym("LOW", KEOP_LOW, 0);
  1183.     reservedsym("LT", KEOP_LT, 0);
  1184.     reservedsym("MOD", KEOP_MOD, 0);
  1185.     reservedsym("NE", KEOP_NE, 0);
  1186.     reservedsym("NOT", KEOP_NOT, 0);
  1187.     reservedsym("OR", KEOP_OR, 0);
  1188.     reservedsym("SHL", KEOP_SHL, 0);
  1189.     reservedsym("SHR", KEOP_SHR, 0);
  1190.     reservedsym("XOR", KEOP_XOR, 0);
  1191.  
  1192.     /* machine specific token definitions */
  1193.     reservedsym("a", REG, REGSEL_ACC);
  1194.     reservedsym("ab", REG, REGSEL_AB);
  1195.     reservedsym("c", REG, REGSEL_C);
  1196.     reservedsym("dptr", REG, REGSEL_DPTR);
  1197.     reservedsym("pc", REG, REGSEL_PC);
  1198.     reservedsym("r0", REG, REGSEL_R01|REGSEL_R07|0);
  1199.     reservedsym("r1", REG, REGSEL_R01|REGSEL_R07|1);
  1200.     reservedsym("r2", REG, REGSEL_R07|2);
  1201.     reservedsym("r3", REG, REGSEL_R07|3);
  1202.     reservedsym("r4", REG, REGSEL_R07|4);
  1203.     reservedsym("r5", REG, REGSEL_R07|5);
  1204.     reservedsym("r6", REG, REGSEL_R07|6);
  1205.     reservedsym("r7", REG, REGSEL_R07|7);
  1206.  
  1207.     reservedsym("A", REG, REGSEL_ACC);
  1208.     reservedsym("AB", REG, REGSEL_AB);
  1209.     reservedsym("C", REG, REGSEL_C);
  1210.     reservedsym("DPTR", REG, REGSEL_DPTR);
  1211.     reservedsym("PC", REG, REGSEL_PC);
  1212.     reservedsym("R0", REG, REGSEL_R01|REGSEL_R07|0);
  1213.     reservedsym("R1", REG, REGSEL_R01|REGSEL_R07|1);
  1214.     reservedsym("R2", REG, REGSEL_R07|2);
  1215.     reservedsym("R3", REG, REGSEL_R07|3);
  1216.     reservedsym("R4", REG, REGSEL_R07|4);
  1217.     reservedsym("R5", REG, REGSEL_R07|5);
  1218.     reservedsym("R6", REG, REGSEL_R07|6);
  1219.     reservedsym("R7", REG, REGSEL_R07|7);
  1220.  
  1221. }
  1222.  
  1223. cpumatch(str)
  1224.     char * str;
  1225. {
  1226.     return TRUE;
  1227. }
  1228.  
  1229. /*
  1230.     description    Opcode and Instruction generation tables
  1231.     usage        Unix, framework crossassembler
  1232.     history        September 25, 1987
  1233. */
  1234.  
  1235. #define NUMOPCODE 68
  1236. #define NUMSYNBLK 107
  1237. #define NUMDIFFOP 125
  1238.  
  1239. int gnumopcode = NUMOPCODE;
  1240.  
  1241. int ophashlnk[NUMOPCODE];
  1242.  
  1243. struct opsym optab[NUMOPCODE+1]
  1244.     = {
  1245.     {"invalid", KOC_opcode, 2, 0 },
  1246.     {"ACALL", KOC_opcode, 1, 2 },
  1247.     {"ADD", KOC_aluop, 4, 3 },
  1248.     {"ADDC", KOC_aluop, 4, 7 },
  1249.     {"AJMP", KOC_opcode, 1, 11 },
  1250.     {"ANL", KOC_aluop, 9, 12 },
  1251.     {"BYTE", KOC_BDEF, 0, 0 },
  1252.     {"CHARDEF", KOC_CHDEF, 0, 0 },
  1253.     {"CHARSET", KOC_CHSET, 0, 0 },
  1254.     {"CHARUSE", KOC_CHUSE, 0, 0 },
  1255.     {"CHD", KOC_CHDEF, 0, 0 },
  1256.     {"CJNE", KOC_cjne, 3, 21 },
  1257.     {"CLR", KOC_opcode, 3, 24 },
  1258.     {"CPL", KOC_opcode, 3, 27 },
  1259.     {"DA", KOC_opcode, 1, 30 },
  1260.     {"DB", KOC_BDEF, 0, 0 },
  1261.     {"DEC", KOC_opcode, 3, 31 },
  1262.     {"DIV", KOC_opcode, 1, 34 },
  1263.     {"DJNZ", KOC_aluop, 2, 35 },
  1264.     {"DW", KOC_WDEF, 0, 0 },
  1265.     {"ELSE", KOC_ELSE, 0, 0 },
  1266.     {"END", KOC_END, 0, 0 },
  1267.     {"ENDI", KOC_ENDI, 0, 0 },
  1268.     {"EQU", KOC_EQU, 0, 0 },
  1269.     {"FCB", KOC_BDEF, 0, 0 },
  1270.     {"FCC", KOC_SDEF, 0, 0 },
  1271.     {"FDB", KOC_WDEF, 0, 0 },
  1272.     {"IF", KOC_IF, 0, 0 },
  1273.     {"INC", KOC_opcode, 3, 37 },
  1274.     {"INCL", KOC_INCLUDE, 0, 0 },
  1275.     {"INCLUDE", KOC_INCLUDE, 0, 0 },
  1276.     {"JB", KOC_aluop, 2, 40 },
  1277.     {"JBC", KOC_aluop, 2, 42 },
  1278.     {"JC", KOC_opcode, 1, 44 },
  1279.     {"JMP", KOC_opcode, 1, 45 },
  1280.     {"JNB", KOC_aluop, 2, 46 },
  1281.     {"JNC", KOC_opcode, 1, 48 },
  1282.     {"JNZ", KOC_opcode, 1, 49 },
  1283.     {"JZ", KOC_opcode, 1, 50 },
  1284.     {"LCALL", KOC_opcode, 1, 51 },
  1285.     {"LJMP", KOC_opcode, 1, 52 },
  1286.     {"MOV", KOC_mov, 13, 53 },
  1287.     {"MOVC", KOC_mov, 1, 66 },
  1288.     {"MOVX", KOC_mov, 2, 67 },
  1289.     {"MUL", KOC_opcode, 1, 69 },
  1290.     {"NOP", KOC_opcode, 1, 70 },
  1291.     {"ORG", KOC_ORG, 0, 0 },
  1292.     {"ORL", KOC_aluop, 9, 71 },
  1293.     {"POP", KOC_opcode, 1, 80 },
  1294.     {"PUSH", KOC_opcode, 1, 81 },
  1295.     {"RESERVE", KOC_RESM, 0, 0 },
  1296.     {"RET", KOC_opcode, 1, 82 },
  1297.     {"RETI", KOC_opcode, 1, 83 },
  1298.     {"RL", KOC_opcode, 1, 84 },
  1299.     {"RLC", KOC_opcode, 1, 85 },
  1300.     {"RMB", KOC_RESM, 0, 0 },
  1301.     {"RR", KOC_opcode, 1, 86 },
  1302.     {"RRC", KOC_opcode, 1, 87 },
  1303.     {"SET", KOC_SET, 0, 0 },
  1304.     {"SETB", KOC_opcode, 3, 88 },
  1305.     {"SJMP", KOC_opcode, 1, 91 },
  1306.     {"STRING", KOC_SDEF, 0, 0 },
  1307.     {"SUBB", KOC_aluop, 4, 92 },
  1308.     {"SWAP", KOC_opcode, 1, 96 },
  1309.     {"WORD", KOC_WDEF, 0, 0 },
  1310.     {"XCH", KOC_aluop, 3, 97 },
  1311.     {"XCHD", KOC_aluop, 1, 100 },
  1312.     {"XRL", KOC_aluop, 6, 101 },
  1313.     { "", 0, 0, 0 }};
  1314.  
  1315. struct opsynt ostab[NUMSYNBLK+1]
  1316.     = {
  1317. /* invalid 0 */ { 0, 1, 0 },
  1318. /* invalid 1 */ { 0xffff, 1, 1 },
  1319. /* ACALL 2 */ { ST_UOP04, 1, 2 },
  1320. /* ADD 3 */ { ST_ALU01, 1, 3 },
  1321. /* ADD 4 */ { ST_ALU03, 1, 4 },
  1322. /* ADD 5 */ { ST_ALU04, 1, 5 },
  1323. /* ADD 6 */ { ST_ALU06, 1, 6 },
  1324. /* ADDC 7 */ { ST_ALU01, 1, 7 },
  1325. /* ADDC 8 */ { ST_ALU03, 1, 8 },
  1326. /* ADDC 9 */ { ST_ALU04, 1, 9 },
  1327. /* ADDC 10 */ { ST_ALU06, 1, 10 },
  1328. /* AJMP 11 */ { ST_UOP04, 1, 11 },
  1329. /* ANL 12 */ { ST_ALU01, 1, 12 },
  1330. /* ANL 13 */ { ST_ALU02, 1, 13 },
  1331. /* ANL 14 */ { ST_ALU02E, 1, 14 },
  1332. /* ANL 15 */ { ST_ALU03, 1, 15 },
  1333. /* ANL 16 */ { ST_ALU04, 1, 16 },
  1334. /* ANL 17 */ { ST_ALU05, 1, 17 },
  1335. /* ANL 18 */ { ST_ALU06, 2, 18 },
  1336. /* ANL 19 */ { ST_ALU08, 1, 20 },
  1337. /* ANL 20 */ { ST_ALU09, 1, 21 },
  1338. /* CJNE 21 */ { ST_CJNE1, 1, 22 },
  1339. /* CJNE 22 */ { ST_CJNE2, 2, 23 },
  1340. /* CJNE 23 */ { ST_CJNE3, 1, 25 },
  1341. /* CLR 24 */ { ST_UOP02, 2, 26 },
  1342. /* CLR 25 */ { ST_UOP03, 1, 28 },
  1343. /* CLR 26 */ { ST_UOP04, 1, 29 },
  1344. /* CPL 27 */ { ST_UOP02, 2, 30 },
  1345. /* CPL 28 */ { ST_UOP03, 1, 32 },
  1346. /* CPL 29 */ { ST_UOP04, 1, 33 },
  1347. /* DA 30 */ { ST_UOP02, 1, 34 },
  1348. /* DEC 31 */ { ST_UOP01, 1, 35 },
  1349. /* DEC 32 */ { ST_UOP02, 2, 36 },
  1350. /* DEC 33 */ { ST_UOP04, 1, 38 },
  1351. /* DIV 34 */ { ST_UOP02, 1, 39 },
  1352. /* DJNZ 35 */ { ST_ALU06, 1, 40 },
  1353. /* DJNZ 36 */ { ST_ALU10, 1, 41 },
  1354. /* INC 37 */ { ST_UOP01, 1, 42 },
  1355. /* INC 38 */ { ST_UOP02, 3, 43 },
  1356. /* INC 39 */ { ST_UOP04, 1, 46 },
  1357. /* JB 40 */ { ST_ALU07, 1, 47 },
  1358. /* JB 41 */ { ST_ALU10, 1, 48 },
  1359. /* JBC 42 */ { ST_ALU07, 1, 49 },
  1360. /* JBC 43 */ { ST_ALU10, 1, 50 },
  1361. /* JC 44 */ { ST_UOP04, 1, 51 },
  1362. /* JMP 45 */ { ST_UOP05, 1, 52 },
  1363. /* JNB 46 */ { ST_ALU07, 1, 53 },
  1364. /* JNB 47 */ { ST_ALU10, 1, 54 },
  1365. /* JNC 48 */ { ST_UOP04, 1, 55 },
  1366. /* JNZ 49 */ { ST_UOP04, 1, 56 },
  1367. /* JZ 50 */ { ST_UOP04, 1, 57 },
  1368. /* LCALL 51 */ { ST_UOP04, 1, 58 },
  1369. /* LJMP 52 */ { ST_UOP04, 1, 59 },
  1370. /* MOV 53 */ { ST_MOV01, 1, 60 },
  1371. /* MOV 54 */ { ST_MOV02, 1, 61 },
  1372. /* MOV 55 */ { ST_MOV03, 1, 62 },
  1373. /* MOV 56 */ { ST_MOV04, 3, 63 },
  1374. /* MOV 57 */ { ST_MOV05, 1, 66 },
  1375. /* MOV 58 */ { ST_MOV07, 2, 67 },
  1376. /* MOV 59 */ { ST_MOV08, 1, 69 },
  1377. /* MOV 60 */ { ST_MOV09, 3, 70 },
  1378. /* MOV 61 */ { ST_MOV10, 1, 73 },
  1379. /* MOV 62 */ { ST_MOV11, 1, 74 },
  1380. /* MOV 63 */ { ST_MOV12, 1, 75 },
  1381. /* MOV 64 */ { ST_MOV13, 3, 76 },
  1382. /* MOV 65 */ { ST_MOV14, 1, 79 },
  1383. /* MOVC 66 */ { ST_MOV06, 2, 80 },
  1384. /* MOVX 67 */ { ST_MOV02, 2, 82 },
  1385. /* MOVX 68 */ { ST_MOV05, 2, 84 },
  1386. /* MUL 69 */ { ST_UOP02, 1, 86 },
  1387. /* NOP 70 */ { ST_INH, 1, 87 },
  1388. /* ORL 71 */ { ST_ALU01, 1, 88 },
  1389. /* ORL 72 */ { ST_ALU02, 1, 89 },
  1390. /* ORL 73 */ { ST_ALU02E, 1, 90 },
  1391. /* ORL 74 */ { ST_ALU03, 1, 91 },
  1392. /* ORL 75 */ { ST_ALU04, 1, 92 },
  1393. /* ORL 76 */ { ST_ALU05, 1, 93 },
  1394. /* ORL 77 */ { ST_ALU06, 2, 94 },
  1395. /* ORL 78 */ { ST_ALU08, 1, 96 },
  1396. /* ORL 79 */ { ST_ALU09, 1, 97 },
  1397. /* POP 80 */ { ST_UOP04, 1, 98 },
  1398. /* PUSH 81 */ { ST_UOP04, 1, 99 },
  1399. /* RET 82 */ { ST_INH, 1, 100 },
  1400. /* RETI 83 */ { ST_INH, 1, 101 },
  1401. /* RL 84 */ { ST_UOP02, 1, 102 },
  1402. /* RLC 85 */ { ST_UOP02, 1, 103 },
  1403. /* RR 86 */ { ST_UOP02, 1, 104 },
  1404. /* RRC 87 */ { ST_UOP02, 1, 105 },
  1405. /* SETB 88 */ { ST_UOP02, 1, 106 },
  1406. /* SETB 89 */ { ST_UOP03, 1, 107 },
  1407. /* SETB 90 */ { ST_UOP04, 1, 108 },
  1408. /* SJMP 91 */ { ST_UOP04, 1, 109 },
  1409. /* SUBB 92 */ { ST_ALU01, 1, 110 },
  1410. /* SUBB 93 */ { ST_ALU03, 1, 111 },
  1411. /* SUBB 94 */ { ST_ALU04, 1, 112 },
  1412. /* SUBB 95 */ { ST_ALU06, 1, 113 },
  1413. /* SWAP 96 */ { ST_UOP02, 1, 114 },
  1414. /* XCH 97 */ { ST_ALU03, 1, 115 },
  1415. /* XCH 98 */ { ST_ALU04, 1, 116 },
  1416. /* XCH 99 */ { ST_ALU06, 1, 117 },
  1417. /* XCHD 100 */ { ST_ALU03, 1, 118 },
  1418. /* XRL 101 */ { ST_ALU01, 1, 119 },
  1419. /* XRL 102 */ { ST_ALU03, 1, 120 },
  1420. /* XRL 103 */ { ST_ALU04, 1, 121 },
  1421. /* XRL 104 */ { ST_ALU06, 1, 122 },
  1422. /* XRL 105 */ { ST_ALU08, 1, 123 },
  1423. /* XRL 106 */ { ST_ALU09, 1, 124 },
  1424.     { 0, 0, 0 } };
  1425.  
  1426. struct igel igtab[NUMDIFFOP+1]
  1427.     = {
  1428. /* invalid 0 */   { 0 , 0, 
  1429.         "[Xnullentry" },
  1430. /* invalid 1 */   { 0 , 0, 
  1431.         "[Xinvalid opcode" },
  1432. /* ACALL 2 */   { 0 , 0, 
  1433.         "[1=].Q.2+.f800&-.bI~.3}.e0&.11|;!.ff&;" },
  1434. /* ADD 3 */   { REGSEL_ACC , REGSEL_ACC, 
  1435.         "24;[2=];" },
  1436. /* ADD 4 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1437.         "26.[2#]|;" },
  1438. /* ADD 5 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1439.         "28.[2#]|;" },
  1440. /* ADD 6 */   { REGSEL_ACC , REGSEL_ACC, 
  1441.         "25;[2=].8I;" },
  1442. /* ADDC 7 */   { REGSEL_ACC , REGSEL_ACC, 
  1443.         "34;[2=];" },
  1444. /* ADDC 8 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1445.         "36.[2#]|;" },
  1446. /* ADDC 9 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1447.         "38.[2#]|;" },
  1448. /* ADDC 10 */   { REGSEL_ACC , REGSEL_ACC, 
  1449.         "35;[2=].8I;" },
  1450. /* AJMP 11 */   { 0 , 0, 
  1451.         "[1=].Q.2+.f800&-.bI~.3}.e0&.01|;!.ff&;" },
  1452. /* ANL 12 */   { REGSEL_ACC , REGSEL_ACC, 
  1453.         "54;[2=];" },
  1454. /* ANL 13 */   { REGSEL_C , REGSEL_C, 
  1455.         "b0;[2#];" },
  1456. /* ANL 14 */   { REGSEL_C , REGSEL_C, 
  1457.         "b0;[2=].8I;" },
  1458. /* ANL 15 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1459.         "56.[2#]|;" },
  1460. /* ANL 16 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1461.         "58.[2#]|;" },
  1462. /* ANL 17 */   { REGSEL_C , REGSEL_C, 
  1463.         "82;[2#];" },
  1464. /* ANL 18 */   { REGSEL_ACC , REGSEL_ACC, 
  1465.         "55;[2=].8I;" },
  1466. /* ANL 19 */   { REGSEL_C , REGSEL_C, 
  1467.         "82;[2=].8I;" },
  1468. /* ANL 20 */   { 0 , 0, 
  1469.         "53;[1=].8I;[2=];" },
  1470. /* ANL 21 */   { REGSEL_ACC , REGSEL_ACC, 
  1471.         "52;[1=].8I;" },
  1472. /* CJNE 22 */   { REGSEL_ACC , REGSEL_ACC, 
  1473.         "b5;[2=].8I;[3=].Q.1+-r" },
  1474. /* CJNE 23 */   { REGSEL_ACC , REGSEL_ACC, 
  1475.         "b4;[2=];[3=].Q.1+-r" },
  1476. /* CJNE 24 */   { REGSEL_R07 , REGSEL_R07, 
  1477.         "b8.[1#]|;[2=];[3=].Q.1+-r" },
  1478. /* CJNE 25 */   { REGSEL_R01 , REGSEL_R01, 
  1479.         "b6.[1#]|;[2=];[3=].Q.1+-r" },
  1480. /* CLR 26 */   { REGSEL_ACC , REGSEL_ACC, 
  1481.         "e4;" },
  1482. /* CLR 27 */   { REGSEL_C , REGSEL_C, 
  1483.         "c3;" },
  1484. /* CLR 28 */   { 0 , 0, 
  1485.         "c2;[1#];" },
  1486. /* CLR 29 */   { 0 , 0, 
  1487.         "c2;[1=].8I;" },
  1488. /* CPL 30 */   { REGSEL_ACC , REGSEL_ACC, 
  1489.         "f4;" },
  1490. /* CPL 31 */   { REGSEL_C , REGSEL_C, 
  1491.         "b3;" },
  1492. /* CPL 32 */   { 0 , 0, 
  1493.         "b2;[1#];" },
  1494. /* CPL 33 */   { 0 , 0, 
  1495.         "b2;[1=].8I;" },
  1496. /* DA 34 */   { REGSEL_ACC , REGSEL_ACC, 
  1497.         "d4;" },
  1498. /* DEC 35 */   { REGSEL_R01 , REGSEL_R01, 
  1499.         "16.[1#]|;" },
  1500. /* DEC 36 */   { REGSEL_ACC , REGSEL_ACC, 
  1501.         "14;" },
  1502. /* DEC 37 */   { REGSEL_R07 , REGSEL_R07, 
  1503.         "18.[1#]|;" },
  1504. /* DEC 38 */   { 0 , 0, 
  1505.         "15;[1=].8I;" },
  1506. /* DIV 39 */   { REGSEL_AB , REGSEL_AB, 
  1507.         "84;" },
  1508. /* DJNZ 40 */   { REGSEL_R07 , REGSEL_R07, 
  1509.         "d8.[1#]|;[2=].Q.1+-r" },
  1510. /* DJNZ 41 */   { 0 , 0, 
  1511.         "d5;[1=].8I;[2=].Q.1+-r" },
  1512. /* INC 42 */   { REGSEL_R01 , REGSEL_R01, 
  1513.         "06.[1#]|;" },
  1514. /* INC 43 */   { REGSEL_ACC , REGSEL_ACC, 
  1515.         "04;" },
  1516. /* INC 44 */   { REGSEL_R07 , REGSEL_R07, 
  1517.         "08.[1#]|;" },
  1518. /* INC 45 */   { REGSEL_DPTR , REGSEL_DPTR, 
  1519.         "a3;" },
  1520. /* INC 46 */   { 0 , 0, 
  1521.         "05;[1=].8I;" },
  1522. /* JB 47 */   { 0 , 0, 
  1523.         "20;[1#];[2=].Q.1+-r" },
  1524. /* JB 48 */   { 0 , 0, 
  1525.         "20;[1=].8I;[2=].Q.1+-r" },
  1526. /* JBC 49 */   { 0 , 0, 
  1527.         "10;[1#];[2=].Q.1+-r" },
  1528. /* JBC 50 */   { 0 , 0, 
  1529.         "10;[1=].8I;[2=].Q.1+-r" },
  1530. /* JC 51 */   { 0 , 0, 
  1531.         "40;[1=].Q.1+-r" },
  1532. /* JMP 52 */   { REGSEL_ACC|REG2SEL_DPTR , REGSEL_ACC|REG2SEL_DPTR, 
  1533.         "73;" },
  1534. /* JNB 53 */   { 0 , 0, 
  1535.         "30;[1#];[2=].Q.1+-r" },
  1536. /* JNB 54 */   { 0 , 0, 
  1537.         "30;[1=].8I;[2=].Q.1+-r" },
  1538. /* JNC 55 */   { 0 , 0, 
  1539.         "50;[1=].Q.1+-r" },
  1540. /* JNZ 56 */   { 0 , 0, 
  1541.         "70;[1=].Q.1+-r" },
  1542. /* JZ 57 */   { 0 , 0, 
  1543.         "60;[1=].Q.1+-r" },
  1544. /* LCALL 58 */   { 0 , 0, 
  1545.         "12;[1=]x" },
  1546. /* LJMP 59 */   { 0 , 0, 
  1547.         "02;[1=]x" },
  1548. /* MOV 60 */   { REGSEL_R01 , REGSEL_R01, 
  1549.         "76.[1#]|;[2=];" },
  1550. /* MOV 61 */   { REGSEL_R01|REG2SEL_ACC , REGSEL_R01|REG2SEL_ACC, 
  1551.         "f6.[1#]|;" },
  1552. /* MOV 62 */   { REGSEL_R01 , REGSEL_R01, 
  1553.         "a6.[1#]|;[2=].8I;" },
  1554. /* MOV 63 */   { REGSEL_ACC , REGSEL_ACC, 
  1555.         "74;[2=];" },
  1556. /* MOV 64 */   { REGSEL_DPTR , REGSEL_DPTR, 
  1557.         "90;[2=]x" },
  1558. /* MOV 65 */   { REGSEL_R07 , REGSEL_R07, 
  1559.         "78.[1#]|;[2=];" },
  1560. /* MOV 66 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1561.         "e6.[2#]|;" },
  1562. /* MOV 67 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1563.         "e8.[2#]|;" },
  1564. /* MOV 68 */   { REGSEL_R07|REG2SEL_ACC , REGSEL_R07|REG2SEL_ACC, 
  1565.         "f8.[1#]|;" },
  1566. /* MOV 69 */   { REGSEL_C , REGSEL_C, 
  1567.         "a2;[2#];" },
  1568. /* MOV 70 */   { REGSEL_ACC , REGSEL_ACC, 
  1569.         "e5;[2=].8I;" },
  1570. /* MOV 71 */   { REGSEL_C , REGSEL_C, 
  1571.         "a2;[2=].8I;" },
  1572. /* MOV 72 */   { REGSEL_R07 , REGSEL_R07, 
  1573.         "a8.[1#]|;[2=].8I;" },
  1574. /* MOV 73 */   { REGSEL_C , REGSEL_C, 
  1575.         "92;[1#];" },
  1576. /* MOV 74 */   { 0 , 0, 
  1577.         "75;[1=].8I;[2=];" },
  1578. /* MOV 75 */   { REGSEL_R01 , REGSEL_R01, 
  1579.         "86.[2#]|;[1=].8I;" },
  1580. /* MOV 76 */   { REGSEL_ACC , REGSEL_ACC, 
  1581.         "f5;[1=].8I;" },
  1582. /* MOV 77 */   { REGSEL_C , REGSEL_C, 
  1583.         "92;[1=].8I;" },
  1584. /* MOV 78 */   { REGSEL_R07 , REGSEL_R07, 
  1585.         "88.[2#]|;[1=].8I;" },
  1586. /* MOV 79 */   { 0 , 0, 
  1587.         "85;[2=].8I;[1=].8I;" },
  1588. /* MOVC 80 */   { REGSEL_ACC|REG2SEL_DPTR , REGSEL_ACC|REG2SEL_DPTR, 
  1589.         "93;" },
  1590. /* MOVC 81 */   { REGSEL_ACC|REG2SEL_PC , REGSEL_ACC|REG2SEL_PC, 
  1591.         "83;" },
  1592. /* MOVX 82 */   { REGSEL_DPTR|REG2SEL_ACC , REGSEL_DPTR|REG2SEL_ACC, 
  1593.         "f0;" },
  1594. /* MOVX 83 */   { REGSEL_R01|REG2SEL_ACC , REGSEL_R01|REG2SEL_ACC, 
  1595.         "f2.[1#]|;" },
  1596. /* MOVX 84 */   { REGSEL_ACC|REG2SEL_DPTR , REGSEL_ACC|REG2SEL_DPTR, 
  1597.         "e0;" },
  1598. /* MOVX 85 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1599.         "e2.[2#]|;" },
  1600. /* MUL 86 */   { REGSEL_AB , REGSEL_AB, 
  1601.         "a4;" },
  1602. /* NOP 87 */   { 0 , 0, 
  1603.         "00;" },
  1604. /* ORL 88 */   { REGSEL_ACC , REGSEL_ACC, 
  1605.         "44;[2=];" },
  1606. /* ORL 89 */   { REGSEL_C , REGSEL_C, 
  1607.         "a0;[2#];" },
  1608. /* ORL 90 */   { REGSEL_C , REGSEL_C, 
  1609.         "a0;[2=].8I;" },
  1610. /* ORL 91 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1611.         "46.[2#]|;" },
  1612. /* ORL 92 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1613.         "48.[2#]|;" },
  1614. /* ORL 93 */   { REGSEL_C , REGSEL_C, 
  1615.         "72;[2#];" },
  1616. /* ORL 94 */   { REGSEL_ACC , REGSEL_ACC, 
  1617.         "45;[2=].8I;" },
  1618. /* ORL 95 */   { REGSEL_C , REGSEL_C, 
  1619.         "72;[2=].8I;" },
  1620. /* ORL 96 */   { 0 , 0, 
  1621.         "43;[1=].8I;[2=];" },
  1622. /* ORL 97 */   { REGSEL_ACC , REGSEL_ACC, 
  1623.         "42;[1=].8I;" },
  1624. /* POP 98 */   { 0 , 0, 
  1625.         "d0;[1=].8I;" },
  1626. /* PUSH 99 */   { 0 , 0, 
  1627.         "c0;[1=].8I;" },
  1628. /* RET 100 */   { 0 , 0, 
  1629.         "22;" },
  1630. /* RETI 101 */   { 0 , 0, 
  1631.         "32;" },
  1632. /* RL 102 */   { REGSEL_ACC , REGSEL_ACC, 
  1633.         "23;" },
  1634. /* RLC 103 */   { REGSEL_ACC , REGSEL_ACC, 
  1635.         "33;" },
  1636. /* RR 104 */   { REGSEL_ACC , REGSEL_ACC, 
  1637.         "03;" },
  1638. /* RRC 105 */   { REGSEL_ACC , REGSEL_ACC, 
  1639.         "13;" },
  1640. /* SETB 106 */   { REGSEL_C , REGSEL_C, 
  1641.         "d3;" },
  1642. /* SETB 107 */   { 0 , 0, 
  1643.         "d2;[1#];" },
  1644. /* SETB 108 */   { 0 , 0, 
  1645.         "d2;[1=].8I;" },
  1646. /* SJMP 109 */   { 0 , 0, 
  1647.         "80;[1=].Q.1+-r" },
  1648. /* SUBB 110 */   { REGSEL_ACC , REGSEL_ACC, 
  1649.         "94;[2=];" },
  1650. /* SUBB 111 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1651.         "96.[2#]|;" },
  1652. /* SUBB 112 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1653.         "98.[2#]|;" },
  1654. /* SUBB 113 */   { REGSEL_ACC , REGSEL_ACC, 
  1655.         "95;[2=].8I;" },
  1656. /* SWAP 114 */   { REGSEL_ACC , REGSEL_ACC, 
  1657.         "c4;" },
  1658. /* XCH 115 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1659.         "c6.[2#]|;" },
  1660. /* XCH 116 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1661.         "c8.[2#]|;" },
  1662. /* XCH 117 */   { REGSEL_ACC , REGSEL_ACC, 
  1663.         "c5;[2=].8I;" },
  1664. /* XCHD 118 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1665.         "d6.[2#]|;" },
  1666. /* XRL 119 */   { REGSEL_ACC , REGSEL_ACC, 
  1667.         "64;[2=];" },
  1668. /* XRL 120 */   { REGSEL_ACC|REG2SEL_R01 , REGSEL_ACC|REG2SEL_R01, 
  1669.         "66.[2#]|;" },
  1670. /* XRL 121 */   { REGSEL_ACC|REG2SEL_R07 , REGSEL_ACC|REG2SEL_R07, 
  1671.         "68.[2#]|;" },
  1672. /* XRL 122 */   { REGSEL_ACC , REGSEL_ACC, 
  1673.         "65;[2=].8I;" },
  1674. /* XRL 123 */   { 0 , 0, 
  1675.         "63;[1=].8I;[2=];" },
  1676. /* XRL 124 */   { REGSEL_ACC , REGSEL_ACC, 
  1677.         "62;[1=].8I;" },
  1678.     { 0,0,""} };
  1679. /* end fraptabdef.c */
  1680.